﻿using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using OpenPasteSpider.Handler;
using OpenPasteSpider.usermodel;
using PasteFormHelper;
using System.Collections;
using System.ComponentModel.DataAnnotations;
using System.Dynamic;
using System.Linq.Dynamic.Core;
using System.Linq.Expressions;
using System.Reflection;
using System.Text.Json.Nodes;
using System.Web;
using Volo.Abp.Auditing;

namespace OpenPasteSpider.Application
{
    /// <summary>
    /// 默认读取 这个很关键，实现了统一的新增 更新 详细 列表规范读取 相当于兜底的!
    /// Version.2025.07.06.02
    /// 当前还有一个问题，就是Page不是采用LeftJoin的，是分次查询，因为LeftJoin的组合有问题，目前还在找办法，Queryable死活会被转换成DbSet... .. .
    ///</summary>
    [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
    [DisableAuditing]
    public class DefaultAppService : OpenPasteSpiderAppService
    {

        #region 以下是具体实现 Version.2025.07.03

        /// <summary>
        /// 读取AddDto的数据模型 用于新增
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
        [Route("/api/app/{entityName}/readAddModel", Order = 10)]
        public VoloModelInfo ReadAddModel([FromRoute] string entityName)
        {
            // 1. 根据实体名称查找对应的实体类型和 DTO 类型
            var entityType = FindEntityType(entityName);
            if (entityType == null)
            {
                throw new PasteCodeException($"找不到对应的实体类型: {entityName}");
            }
            var dtoType = FindDtoType(entityName, "AddDto");

            if (dtoType == null)
            {
                throw new PasteCodeException($"找不到对应的 DTO 类型: {entityName}AddDto");
            }

            //new一个出来
            var dto = Activator.CreateInstance(dtoType);

            // 4. 动态读取 DTO 的属性信息
            var dataModel = ReadModelProperties(dto, dtoType);

            return dataModel;

        }

        /// <summary>
        /// 用于更新表单
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpGet]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
        [Route("/api/app/{entityName}/{id}/readUpdateModel", Order = 10)]
        public async Task<VoloModelInfo> ReadUpdateModel([FromRoute] string entityName, [FromRoute] int id)
        {
            // 1. 根据实体名称查找对应的实体类型和 DTO 类型
            var entityType = FindEntityType(entityName);
            var dtoType = FindDtoType(entityName, "UpdateDto");

            if (entityType == null || dtoType == null)
            {
                throw new PasteCodeException($"找不到对应的实体或 DTO 类型: {entityName}");
            }
            // 2. 动态查询实体
            var entity = await FindEntityByIdAsync(entityType, id);
            if (entity == null)
            {
                throw new PasteCodeException("查询的信息不存在，无法执行编辑操作！");
            }
            // 3. 动态映射实体到 DTO
            var dto = MapEntityToDto(entity, entityType, dtoType);

            //构建外表等 Include的如何搞定？？？
            await BuildOuterQuery(dto, dtoType);

            // 4. 动态读取 DTO 的属性信息
            var dataModel = ReadModelProperties(dto, dtoType);
            return dataModel;
        }

        /// <summary>
        /// 用于查看详情
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("/api/app/{entityName}/{id}/readDetailModel", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
        public async Task<VoloModelInfo> ReadDetailModel([FromRoute] string entityName, [FromRoute] int id)
        {
            //var _info = await _dbContext.StoreCashWay.Where(x => x.Id == id).AsNoTracking().FirstOrDefaultAsync();
            //if (_info == null || _info == default)
            //{
            //    throw new PasteCodeException("查询的信息不存在，无法执行编辑操作！");
            //}
            //var dto = ObjectMapper.Map<StoreCashWay, StoreCashWayDto>(_info);
            //var _dataModel = PasteBuilderHelper.ReadModelProperty<StoreCashWayDto>(dto);
            //return _dataModel;

            // 1. 根据实体名称查找对应的实体类型和 DTO 类型
            var entityType = FindEntityType(entityName);
            var dtoType = FindDtoType(entityName, "Dto");

            if (entityType == null || dtoType == null)
            {
                throw new PasteCodeException($"找不到对应的实体或 DTO 类型: {entityName}");
            }

            // 2. 动态查询实体
            var entity = await FindEntityByIdAsync(entityType, id);
            if (entity == null)
            {
                throw new PasteCodeException("查询的信息不存在，无法执行编辑操作！");
            }

            // 3. 动态映射实体到 DTO
            var dto = MapEntityToDto(entity, entityType, dtoType);

            //构建外表等 Include的如何搞定？？？
            await BuildOuterQuery(dto, dtoType);

            // 4. 动态读取 DTO 的属性信息
            var dataModel = ReadModelProperties(dto, dtoType);

            return dataModel;

        }

        /// <summary>
        /// 用户查看表格
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("/api/app/{entityName}/readListModel", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
        public VoloModelInfo ReadListModel([FromRoute] string entityName, string searchName = "InputSearchBase")
        {
            // 动态查找实体对应的 ListDto 类型
            var listDtoType = FindDtoType(entityName, "ListDto");
            // 创建 ListDto 实例
            var listDtoInstance = Activator.CreateInstance(listDtoType);
            // 动态读取 ListDto 的属性信息
            //var listModel = PasteBuilderHelper.ReadModelProperty(listDtoInstance, true);
            var listModel = ReadModelProperties(listDtoInstance, listDtoType, true);
            if (searchName != "InputSearchBase")
            {
                // 保持搜索模型的静态处理（假设 InputSearchBase 是固定类）
                var searchModel = PasteBuilderHelper.ReadModelProperty(new InputSearchBase());
                if (searchModel != null)
                {
                    listModel.QueryProperties = searchModel.Properties;
                }
            }
            else
            {
                var search_type = FindType(searchName);
                if (search_type != null)
                {
                    var search_model = Activator.CreateInstance(search_type);
                    //var searchModel = PasteBuilderHelper.ReadModelProperty(search_model);
                    var searchModel = ReadModelProperties(search_model, search_type, true);
                    if (searchModel != null)
                    {
                        listModel.QueryProperties = searchModel.Properties;
                    }
                }
            }
            return listModel;
        }

        /// <summary>
        /// 简单按页查询 不涉及Left Join等
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="searchName"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpGet]
        [Route("/api/app/{entityName}/page", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "view" })]
        public async Task<dynamic> Page([FromRoute] string entityName, string searchName = "InputSearchBase")
        {
            // [FromQuery] InputSearchBase input
            // 1. 根据实体名称查找对应的实体类型和DTO类型
            var entityType = FindEntityType(entityName);
            var listDtoType = FindDtoType(entityName, "ListDto");

            if (entityType == null || listDtoType == null)
            {
                throw new PasteCodeException($"找不到对应的实体或DTO类型: {entityName}", 404);
            }

            var query_string = base._httpContext.Request.QueryString.ToString();
            var querys = query_string.ToQuerys();
            foreach (var key in querys.Keys)
            {
                querys[key] = HttpUtility.UrlDecode(querys[key]);
            }
            var query_body = JsonConvert.SerializeObject(querys);
            //获取基础的
            var input = JsonConvert.DeserializeObject<InputSearchBase>(query_body);
            //Console.WriteLine("line.219");
            Type searchType = null;
            object searchObject = null;

            if (searchName != "InputSearchBase")
            {
                searchType = FindType(searchName);
                searchObject = JsonConvert.DeserializeObject(query_body, searchType);
                //未完待续，后续扩展，更多其他字段查询
            }
            //Console.WriteLine("line.229");
            IQueryable query = null;

            if (searchName == "InputSearchBase")
            {
                // 2. 动态构建查询
                query = BuildDynamicQuery(entityType, input);
            }
            else
            {
                query = BuildDynamicQuery(entityType, searchType, searchObject);
            }
            // 3. 计算总记录数（仅第一页需要）
            //var pagedDtoType = typeof(PagedResultDto<>).MakeGenericType(listDtoType);
            //dynamic pagedDto = Activator.CreateInstance(pagedDtoType);
            //Console.WriteLine("line.244");
            dynamic pagedto = new ExpandoObject();

            if (input.page == 1)
            {
                pagedto.totalCount = await ExecuteCountQuery(query, entityType);
            }

            if (searchName == "InputSearchBase")
            {
                query = ApplyPagingAndSorting(query, entityType, input);
                // 4. 应用分页和排序
                //var pagedQuery = ApplyPagingAndSorting(query, entityType, input);
            }
            else
            {
                query = ApplyPagingAndSorting(query, entityType, searchType, searchObject);
            }
            // 5. 执行查询并获取结果
            //var entities = await ExecuteQuery(query, entityType);
            //if (entities == null || entities.Count == 0)
            //{
            //    return null;
            //}
            //var dtos = MapEntitiesToDtos(entities, entityType, listDtoType);

            var dtos = await ExecuteProjectionQuery(query, entityType, listDtoType);
            if (dtos?.Any() == false)
            {
                return null;
            }

            // 6. 动态映射实体到DTO


            //查询外表 并实现 这里是简单的外表ID的查询 如果有更复杂的，还需要实现
            await BuildOuterData(listDtoType, dtos);
            // 7. 设置结果并返回
            //pagedDto.Items = dtos.Cast<object>().ToList();
            pagedto.items = dtos;
            return pagedto;
        }

        /// <summary>
        /// 通用创建方法
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpPost]
        [Route("/api/app/{entityName}/item", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "add" })]
        public async Task<dynamic> CreateItemAsync([FromRoute] string entityName, [FromBody] JsonObject input)
        {
            // 获取实体类型和添加DTO类型
            var entityType = FindEntityType(entityName);
            var addDtoType = FindDtoType(entityName, "AddDto");

            if (entityType == null || addDtoType == null)
            {
                throw new PasteCodeException($"找不到对应的实体或添加DTO类型: {entityName}", 404);
            }
            ////Console.WriteLine($"line.769 {input.ToString()} {input.ToJsonString()}");
            // 反序列化输入数据到添加DTO
            var addDto = JsonConvert.DeserializeObject(input.ToJsonString(), addDtoType);
            ValidateModel(addDto, addDtoType);



            // 创建实体实例
            var entity = Activator.CreateInstance(entityType);

            // 映射DTO到实体
            MapProperties(addDto, entity, addDtoType, entityType);


            //填充预定值
            //foreach (var pro in entityType.GetProperties())
            //{
            //    switch (pro.Name)
            //    {
            //        case "UserId":
            //        case "CreateUserId":
            //            {
            //                var user_id = base.ReadCurrentUserId();
            //                SetPropertyValue(entity, pro.Name, user_id);
            //            }
            //            break;
            //        default:
            //            break;
            //    }
            //}

            //下面这个和上面注释的意思一样
            base.DefaultBeforeCreate(entityType.GetProperties(), entity);

            // 添加到数据库
            var dbSet = GetDbSet(entityType);
            dbSet.GetType().GetMethod("Add").Invoke(dbSet, new[] { entity });

            // 保存更改
            await _dbContext.SaveChangesAsync();
            //Console.WriteLine("line.869");
            var find_id = entityType.GetProperties().Where(x => x.Name == "Id").FirstOrDefault();
            if (find_id != null && find_id != default)
            {
                return find_id.GetValue(entity).ToString();
            }

            return null;

            //// 映射实体到返回DTO
            //var returnDtoType = FindDtoType(entityName, "Dto");
            //var returnDto = Activator.CreateInstance(returnDtoType);
            //MapProperties(entity, returnDto, entityType, returnDtoType);

            //return returnDto;
        }

        /// <summary>
        /// 通用更新方法
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpPost]
        [Route("/api/app/{entityName}/updateItem", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "edit" })]
        public async Task<object> UpdateItemAsync([FromRoute] string entityName, [FromBody] JsonObject input)
        {
            // 获取实体类型和更新DTO类型
            var entityType = FindEntityType(entityName);
            var updateDtoType = FindDtoType(entityName, "UpdateDto");

            if (entityType == null || updateDtoType == null)
            {
                throw new PasteCodeException($"找不到对应的实体或更新DTO类型: {entityName}", 404);
            }

            // 反序列化输入数据到更新DTO
            var updateDto = JsonConvert.DeserializeObject(input.ToString(), updateDtoType);

            // 手动执行模型验证
            ValidateModel(updateDto, updateDtoType);

            // 获取ID属性值
            var id = GetPropertyValue(updateDto, "Id");
            if (id == null)
            {
                throw new PasteCodeException("更新DTO必须包含Id属性", 400);
            }

            // 查找实体
            var entity = await FindEntityByIdAsync(entityType, id);
            if (entity == null)
            {
                throw new PasteCodeException("需要更新的记录不存在", 404);
            }

            // 映射DTO到实体
            MapProperties(updateDto, entity, updateDtoType, entityType);

            //foreach (var pro in entityType.GetProperties())
            //{
            //    switch (pro.Name)
            //    {
            //        case "UpdateTime":
            //        case "UpdateDate":
            //            {
            //                SetPropertyValue(entity, pro.Name, DateTime.Now);
            //            }
            //            break;
            //        default:
            //            break;
            //    }
            //}
            //下面这个和上面注释的意思一样
            base.DefaultBeforeUpdate(entityType.GetProperties(), entity);


            // 保存更改
            await _dbContext.SaveChangesAsync();


            //var find_id = entityType.GetProperties().Where(x => x.Name == "Id").FirstOrDefault();
            //if (find_id != null && find_id != default)
            //{
            //    return find_id.GetValue(dbSet);
            //}

            return id;

            //// 映射实体到返回DTO
            //var returnDtoType = FindDtoType(entityName, "Dto");
            //var returnDto = Activator.CreateInstance(returnDtoType);
            //MapProperties(entity, returnDto, entityType, returnDtoType);

            //return returnDto;
        }

        /// <summary>
        /// 通用状态更新方法
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpPost]
        [Route("/api/app/{entityName}/updateState", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "state" })]
        public async Task<string> UpdateState([FromRoute] string entityName, [FromBody] InputQueryUpdateState input)
        {
            // 获取实体类型
            var entityType = FindEntityType(entityName);

            if (entityType == null)
            {
                throw new PasteCodeException($"找不到对应的实体类型: {entityName}", 404);
            }

            // 解析ID
            if (!int.TryParse(input.id, out var id))
            {
                throw new PasteCodeException("提供的参数id错误，无法继续执行", 400);
            }

            // 查找实体
            var entity = await FindEntityByIdAsync(entityType, id);
            if (entity == null)
            {
                throw new PasteCodeException("没有找到对应的操作对象，无法继续执行", 404);
            }

            // 获取实体的所有布尔类型属性
            var booleanProperties = entityType.GetProperties()
                .Where(p => p.PropertyType == typeof(bool) || p.PropertyType == typeof(bool?))
                .ToDictionary(p => p.Name, p => p);

            //if (!booleanProperties.ContainsKey(input.name.ToLower()))
            //{
            //    throw new PasteCodeException($"实体 {entityName} 中不存在布尔属性: {input.name}", 400);
            //}
            //input.name isEnable转 IsEnable
            var current_pro = ConvertToPascalCase(input.name);
            if (booleanProperties.ContainsKey(current_pro))
            {
                // 获取属性信息并更新值
                var property = booleanProperties[current_pro];
                if (!property.CanWrite)
                {
                    throw new PasteCodeException($"属性 {input.name} 不可写", 400);
                }

                // 处理可空布尔类型
                if (property.PropertyType == typeof(bool?))
                {
                    property.SetValue(entity, input.state ? (bool?)true : (bool?)false);
                }
                else
                {
                    property.SetValue(entity, input.state);
                }
                // 保存更改
                await _dbContext.SaveChangesAsync();
            }
            else
            {
                Logger.LogWarning($"没有找到这个字段信息:{current_pro} {input.name}");
            }



            return "提交成功";
        }

        /// <summary>
        /// 通用删除 遵照ListDto的PasteDisable特性
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        [HttpPost]
        [Route("/api/app/{entityName}/remove", Order = 10)]
        [TypeFilter(typeof(RoleAttribute), Arguments = new object[] { "data", "del" })]
        public async Task<string> Remove([FromRoute] string entityName, [FromQuery] int id)
        {
            // 获取实体类型
            var entityType = FindEntityType(entityName);

            if (entityType == null)
            {
                throw new PasteCodeException($"找不到对应的实体类型: {entityName}", 404);
            }

            var listDtoType = FindDtoType(entityName, "ListDto");
            if (listDtoType != null)
            {
                var finds = listDtoType.GetCustomAttributes<PasteDisableAttribute>();
                if (finds?.Any() == true)
                {
                    var find = finds.FirstOrDefault();
                    if (find.Args3 == "del")
                    {
                        throw new PasteCodeException($"实体 {entityName} 不允许删除操作", 403);
                    }
                }
            }

            // 查找实体
            var entity = await FindEntityByIdAsync(entityType, id);
            if (entity == null)
            {
                throw new PasteCodeException("需要删除的记录不存在", 404);
            }

            // 执行删除操作
            var dbSet = GetDbSet(entityType);
            dbSet.GetType().GetMethod("Remove").Invoke(dbSet, new[] { entity });

            // 保存更改
            await _dbContext.SaveChangesAsync();

            return "删除成功";
        }


        #region 以下是辅助函数

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="dtoType"></param>
        /// <returns></returns>
        private async Task BuildOuterQuery(object dto, Type dtoType)
        {
            #region 看看是否要执行外表查询
            foreach (var aty in dtoType.GetProperties())
            {
                //var _type = aty.PropertyType;
                var attributes = aty.GetCustomAttributes<PasteShortAttribute>();
                if (attributes?.Any() == true)
                {
                    var short_attr = attributes.FirstOrDefault();
                    if (short_attr != null && short_attr != default)
                    {
                        var foreignKeyId = aty.GetValue(dto);
                        if (foreignKeyId == null || foreignKeyId.Equals(0))
                        {
                            continue;
                        }
                        var shortAttr = short_attr;
                        //var pro_val =//??? 当前字段的值
                        //short_attr.Args1 = "GradeInfo";//表示对应的外表的EntityName
                        //short_attr.Args2 = "ExtendGrade";//表示结果写入到这个字段
                        //short_attr.Args3 = "ToShortUser()";//表示要转换的类型 比如_dbContext.GradeInfo.Where(x=>x.Id==pro_val).Select(x=>x.ToShortUser()).FirstOrDefaultAsync();
                        //如何获取字段的当前值?
                        //await _dbContext.GradeInfo.Where(x => x.Id == 1).Select(y => y.ToShortGrade()).FirstOrDefaultAsync();
                        //ToShortGrade()是GradeInfo的扩展，返回的就是ExtendGrade的类型

                        // 获取外表的Entity类型和目标属性
                        var relatedEntityType = FindEntityType(shortAttr.Args1);
                        var targetProperty = dtoType.GetProperty(shortAttr.Args2);

                        if (relatedEntityType == null || targetProperty == null)
                        {
                            continue;
                        }
                        try
                        {
                            // 获取关联实体的DbSet
                            var dbSet = _dbContext.GetType()
                                .GetProperties()
                                .First(p => p.PropertyType.GenericTypeArguments.Contains(relatedEntityType))
                                .GetValue(_dbContext);

                            // 动态调用FindAsync方法获取关联实体
                            var findAsyncMethod = dbSet.GetType()
                                .GetMethod("FindAsync", new[] { typeof(object[]) });

                            // 执行查询
                            var valueTask = findAsyncMethod.Invoke(dbSet, new object[] { new object[] { foreignKeyId } });

                            // 获取ValueTask的结果
                            object relatedEntity;

                            // 检查是否是ValueTask
                            if (valueTask.GetType().Name.StartsWith("ValueTask"))
                            {
                                // 手动获取ValueTask的结果
                                var getAwaiterMethod = valueTask.GetType().GetMethod("GetAwaiter");
                                var awaiter = getAwaiterMethod.Invoke(valueTask, null);

                                var getResultMethod = awaiter.GetType().GetMethod("GetResult");
                                relatedEntity = getResultMethod.Invoke(awaiter, null);
                            }
                            else
                            {
                                // 普通Task，直接等待
                                await (Task)valueTask;
                                relatedEntity = ((Task<object>)valueTask).Result;
                            }


                            if (relatedEntity != null)
                            {
                                // 处理转换逻辑
                                object convertedResult = null;

                                // 检查是否需要特殊转换
                                if (!string.IsNullOrEmpty(shortAttr.Args3))
                                {
                                    var extend = typeof(LinqExtend).GetMethod(shortAttr.Args3.Replace("()", ""), new[] { relatedEntityType });
                                    // 处理特殊转换方法（例如：ToShortUser()）
                                    //convertedResult = ConvertEntity(relatedEntity, relatedEntityType, shortAttr.Args3);
                                    convertedResult = extend.Invoke(null, new object[] { relatedEntity });
                                }
                                else
                                {
                                    // 默认转换：直接使用目标属性类型
                                    convertedResult = relatedEntity;
                                }

                                // 设置目标属性的值
                                targetProperty.SetValue(dto, convertedResult);
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.LogError(ex, $"加载关联数据失败: {shortAttr.Args1}");
                            // 可以选择记录错误但继续处理其他属性
                        }
                        //------------------------------------------------
                    }
                }
            }

            #endregion
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="entityName"></param>
        /// <returns></returns>
        private Type FindEntityType(string entityName)
        {
            // 将前端传递的名称转换为 PascalCase (例如: storeCashWay -> StoreCashWay)
            var pascalCaseName = ConvertToPascalCase(entityName);
            var assembly = typeof(UserInfo).Assembly;//这里对不对呢... .. .
            return assembly.GetTypes().FirstOrDefault(t => t.Name == entityName || t.Name == $"{pascalCaseName}");//这里可能有问题了

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="suffix"></param>
        /// <returns></returns>
        private Type FindDtoType(string entityName, string suffix)
        {
            var pascalCaseName = ConvertToPascalCase(entityName);
            var dtoName = $"{pascalCaseName}{suffix}";

            return typeof(InputSearchBase).Assembly.GetTypes().FirstOrDefault(t => t.Name == dtoName);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="typeName"></param>
        /// <returns></returns>
        private Type FindType(string typeName)
        {
            var assembly = Assembly.GetExecutingAssembly();
            //return assembly.GetTypes().FirstOrDefault(t => t.Name == typeName);
            return typeof(InputSearchBase).Assembly.GetTypes().FirstOrDefault(t => t.Name == typeName);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="entityType"></param>
        /// <param name="id"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        private async Task<object> FindEntityByIdAsync(Type entityType, object id, CancellationToken cancellationToken = default)
        {
            // 获取实体对应的 DbSet 属性
            var dbSetProperty = _dbContext.GetType()
                .GetProperties()
                .FirstOrDefault(p =>
                    p.PropertyType.IsGenericType &&
                    p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>) &&
                    p.PropertyType.GetGenericArguments()[0] == entityType);

            if (dbSetProperty == null)
            {
                throw new PasteCodeException($"找不到实体 {entityType.Name} 的 DbSet");
            }

            // 获取 DbSet 实例
            var dbSet = dbSetProperty.GetValue(_dbContext);

            // 获取 FindAsync 方法
            var findAsyncMethod = dbSet.GetType()
                .GetMethod("FindAsync", new[] { typeof(object[]), typeof(CancellationToken) });

            // 调用方法
            var valueTask = findAsyncMethod.Invoke(dbSet, new object[] { new object[] { id }, cancellationToken });

            // 处理 ValueTask<T>
            if (valueTask is Task task)
            {
                await task;
                var resultProperty = task.GetType().GetProperty("Result");
                return resultProperty.GetValue(task);
            }
            else
            {
                // 手动处理 ValueTask<T>
                var getAwaiterMethod = valueTask.GetType().GetMethod("GetAwaiter");
                var awaiter = getAwaiterMethod.Invoke(valueTask, null);

                var getResultMethod = awaiter.GetType().GetMethod("GetResult");
                return getResultMethod.Invoke(awaiter, null);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceType"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        private MethodInfo GetMapMethod(Type sourceType, Type destinationType)
        {
            // 获取 Map<TSource, TDestination> 方法定义
            var map = base.ObjectMapper;
            var mapMethod = typeof(Volo.Abp.ObjectMapping.IObjectMapper)
                .GetMethods(BindingFlags.Public | BindingFlags.Instance)
                .FirstOrDefault(m =>
                    m.Name == "Map" &&
                    m.IsGenericMethodDefinition &&
                    m.GetGenericArguments().Length == 2 &&
                    m.GetParameters().Length == 1
                );

            if (mapMethod == null)
            {
                throw new InvalidOperationException("未找到 Map<TSource, TDestination> 方法");
            }

            // 构造具体的泛型方法
            return mapMethod.MakeGenericMethod(sourceType, destinationType);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceInstance"></param>
        /// <param name="sourceType"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public object MapEntityToDto(object sourceInstance, Type sourceType, Type destinationType)
        {
            // 获取 ObjectMapper 实例
            var mapper = ObjectMapper;

            // 获取映射方法
            var mapMethod = GetMapMethod(sourceType, destinationType);

            // 调用映射方法
            return mapMethod.Invoke(ObjectMapper, new object[] { sourceInstance });
        }

        /// <summary>
        /// 动态读取模型属性
        /// </summary>
        /// <param name="model"></param>
        /// <param name="modelType"></param>
        /// <param name="IsListModel">针对枚举的备注过滤</param>
        /// <returns></returns>
        private VoloModelInfo ReadModelProperties(object model, Type modelType, bool IsListModel = false)
        {
            // 获取目标泛型方法定义
            var genericMethodDefinition = typeof(PasteBuilderHelper)
                .GetMethods(BindingFlags.Public | BindingFlags.Static)
                .First(m => m.Name == "DynamicReadModelProperty" && m.IsGenericMethodDefinition);

            // 构建具体的泛型方法（传入实际类型参数）
            var constructedGenericMethod = genericMethodDefinition
                .MakeGenericMethod(modelType);

            // 调用方法并转换结果
            return (VoloModelInfo)constructedGenericMethod
                .Invoke(null, new object[] { model, IsListModel });
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        private string ConvertToPascalCase(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }
            if (char.IsUpper(input[0]))
            {
                return input;
            }
            return input.Substring(0, 1).ToUpper() + input.Substring(1);
        }

        #endregion



        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <param name="modelType"></param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="PasteCodeException"></exception>
        private void ValidateModel(object model, Type modelType)
        {
            if (model == null)
                throw new ArgumentNullException(nameof(model));

            var validationResults = new List<ValidationResult>();
            var validationContext = new ValidationContext(model);

            if (!Validator.TryValidateObject(model, validationContext, validationResults, true))
            {
                var errorMessages = validationResults
                    .SelectMany(r => r.MemberNames.Select(n => $"{n}: {r.ErrorMessage}"))
                    .ToList();

                throw new PasteCodeException("输入数据验证失败", 400);
            }
            else
            {
                //Console.WriteLine($"{modelType.FullName} 验证通过!");
            }
        }

        /// <summary>
        /// 补充Extend外表查询 比如ExtendUser 可能有多个
        /// </summary>
        /// <param name="listDtoType"></param>
        /// <param name="dtos"></param>
        /// <returns></returns>
        private async Task BuildOuterData(Type listDtoType, List<object> dtos)
        {
            var sears = listDtoType.GetProperties().Where(x => x.GetCustomAttributes<PasteShortAttribute>().Any()).ToList();
            if (sears?.Any() == true)
            {
                foreach (var _search in sears)
                {
                    var short_attr = _search.GetCustomAttributes<PasteShortAttribute>().FirstOrDefault();
                    if (short_attr != null && short_attr != default)
                    {
                        var out_id_field = _search.Name;//UserId
                        var out_entity_name = short_attr.Args1;//UserInfo
                        var to_extend = short_attr.Args2;//ExtendUser

                        var target_property = listDtoType.GetProperties().Where(x => x.Name == to_extend).FirstOrDefault();
                        if (target_property == null || target_property == default)
                        {
                            continue;
                        }

                        var relatedDtoType = target_property.PropertyType;

                        var ids = new HashSet<object>();
                        foreach (var dto in dtos)
                        {
                            var id = dto.GetType().GetProperty(out_id_field)?.GetValue(dto);
                            if (id != null)
                            {
                                ids.Add(id);
                            }
                        }
                        if (ids.Count > 0)
                        {
                            //从数据库读取数据
                            var relatedEntityType = FindEntityType(out_entity_name);
                            //转换成对应的dto
                            //赋值
                            if (relatedEntityType == null)
                            {
                                continue;
                            }

                            // 构建ID查询条件
                            var relatedQuery = BuildIdQuery(relatedEntityType, ids);

                            //先查询出Entitys再Mapper
                            //var relatedEntities = await ExecuteQuery(relatedQuery, relatedEntityType);
                            //if (relatedEntities?.Any() == false)
                            //{
                            //    continue;
                            //}
                            //var relatedDtos = MapEntitiesToDtos(relatedEntities, relatedEntityType, relatedDtoType);
                            //直接查询Dto
                            var relatedDtos = await ExecuteProjectionQuery(relatedQuery, relatedEntityType, relatedDtoType);

                            // 3. 创建ID到DTO的映射字典
                            var idToDto = relatedDtos.ToDictionary(d => d.GetType().GetProperty("Id")?.GetValue(d));

                            // 4. 填充到主表DTO
                            foreach (var dto in dtos)
                            {
                                //获取UserId的值
                                var id = dto.GetType().GetProperty(out_id_field)?.GetValue(dto);
                                if (id != null && idToDto.TryGetValue(id, out var relatedDto))
                                {
                                    //给ExtendUser填充值
                                    dto.GetType().GetProperty(to_extend)?.SetValue(dto, relatedDto);
                                }
                            }

                        }

                    }
                }
            }
        }


        #region Page的辅助方法

        /// <summary>
        /// 动态构建查询的方法
        /// </summary>
        /// <param name="entityType"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        private IQueryable BuildDynamicQuery(Type entityType, InputSearchBase input)
        {
            // 获取DbSet方法
            var dbSetMethod = _dbContext.GetType()
                .GetMethods()
                .First(m => m.Name == "Set" && m.IsGenericMethod);

            // 调用DbSet<TEntity>方法
            var genericDbSetMethod = dbSetMethod.MakeGenericMethod(entityType);
            var dbSet = genericDbSetMethod.Invoke(_dbContext, null);

            // 获取IQueryable接口
            var queryable = (IQueryable)dbSet;

            // 应用过滤条件
            queryable = ApplyFilterConditions(queryable, entityType, input.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance), input);

            return queryable;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="entityType"></param>
        /// <param name="searchType"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        private IQueryable BuildDynamicQuery(Type entityType, Type searchType, object input)
        {
            // 获取DbSet方法
            var dbSetMethod = _dbContext.GetType()
                .GetMethods()
                .First(m => m.Name == "Set" && m.IsGenericMethod);

            // 调用DbSet<TEntity>方法
            var genericDbSetMethod = dbSetMethod.MakeGenericMethod(entityType);
            var dbSet = genericDbSetMethod.Invoke(_dbContext, null);

            // 获取IQueryable接口
            var queryable = (IQueryable)dbSet;

            // 应用过滤条件
            queryable = ApplyFilterConditions(queryable, entityType, searchType.GetProperties(BindingFlags.Public | BindingFlags.Instance), input);

            return queryable;
        }

        /// <summary>
        /// 应用过滤条件的方法
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <param name="properties"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        private IQueryable ApplyFilterConditions(IQueryable query, Type entityType, PropertyInfo[] properties, object input)
        {
            // 获取输入对象的所有属性
            //var properties = input.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

            var ignors = new List<string> { "page", "size", "orderby" };

            foreach (var property in properties)
            {
                if (ignors.Contains(property.Name))
                {
                    continue;
                }
                // 跳过不需要作为过滤条件的属性
                //if (property.Name == "page" || property.Name == "size" || property.Name == "orderby" || property.GetValue(input) == null)
                //{
                //    continue;
                //}

                // 获取属性值
                var value = property.GetValue(input);

                if (IsDefaultValue(value, property.PropertyType))
                {
                    continue;
                }

                // 特殊处理搜索关键词
                if (property.Name == "word" && !string.IsNullOrEmpty(value?.ToString()))
                {
                    //是否要一个字段标记这个?
                    query = ApplySearchKeyword(query, entityType, value.ToString());

                    continue;
                }

                //Logger.LogInformation($"Search Property.Name: {property.Name} Type:{property.PropertyType.Name} FullName:{property.PropertyType.FullName}");

                var btype = property.PropertyType;

                if (btype == typeof(bool))
                {
                    var pro = FindSearchProperty(property, entityType);
                    if (pro != null)
                    {
                        query = ApplyComparisonFilter(query, entityType, pro, value, ReturnOperator(property));
                    }
                    continue;
                }

                if (btype == typeof(DateTime) || btype == typeof(DateTime?))
                {
                    if (property.GetCustomAttributes<PasteDaterangeAttribute>()?.Any() == true)
                    {
                        var find = property.GetCustomAttributes<PasteDaterangeAttribute>().FirstOrDefault();
                        if (find != null && find != default)
                        {
                            var edate_pro = find.Args2;
                            var sdate_str = property.GetValue(input);
                            var end_property = properties.Where(x => x.Name == edate_pro).FirstOrDefault();
                            if (end_property != null && end_property != default)
                            {
                                if (DateTime.TryParse(sdate_str.ToString(), out var sdate))
                                {
                                    var edate_str = end_property.GetValue(input);
                                    if (DateTime.TryParse(edate_str.ToString(), out var edate))
                                    {
                                        var pro = FindSearchProperty(property, entityType);
                                        if (pro != null)
                                        {
                                            query = ApplyComparisonFilter(query, entityType, pro, sdate, "LessThanOrEqual");
                                            query = ApplyComparisonFilter(query, entityType, pro, edate, "GreaterThanOrEqual");
                                        }
                                        else
                                        {
                                            Logger.LogInformation("没有在字段:{0} 中找到对应的字段 是否配置了PasteField特性 !", property.Name);
                                        }
                                    }
                                }
                            }
                            ignors.Add(edate_pro);
                        }
                    }
                    continue;
                }

                if (btype == typeof(string))
                {
                    var pro = FindSearchProperty(property, entityType);
                    if (pro != null)
                    {
                        query = ApplyComparisonFilter(query, entityType, pro, value.ToString(), ReturnOperator(property));
                    }
                    continue;
                }

                ////是否有PasteFieldAttribute特性 比如 user_id实际为UserId
                //var target_property = property.Name;
                //if (property.GetCustomAttributes<PasteFieldAttribute>()?.Any() == true)
                //{
                //    var find = property.GetCustomAttributes<PasteFieldAttribute>().FirstOrDefault();
                //    if (find != null && find != default)
                //    {
                //        target_property = find.Args1;
                //    }
                //}
                //// 检查实体是否有对应的属性
                //var entityProperty = entityType.GetProperty(target_property);
                //if (entityProperty != null && entityProperty.PropertyType == property.PropertyType)
                //{
                //    // 动态构建表达式: x => x.Property == value
                //    query = ApplyEqualsFilter(query, entityType, entityProperty, value);
                //}

            }
            return query;
        }

        /// <summary>
        /// 获取运算符
        /// </summary>
        /// <param name="property"></param>
        /// <returns></returns>
        private string ReturnOperator(PropertyInfo property)
        {
            var finds = property.GetCustomAttributes<PasteFieldAttribute>();
            if (finds?.Any() == true)
            {
                var find = finds.FirstOrDefault();
                if (find != null && find != default)
                {
                    if (!String.IsNullOrEmpty(find.Args2))
                    {
                        return find.Args2;
                    }
                }
            }
            return "Equals";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="property"></param>
        /// <param name="entityType"></param>
        /// <returns></returns>
        private PropertyInfo FindSearchProperty(PropertyInfo property, Type entityType)
        {
            var target_property = property.Name;
            if (property.GetCustomAttributes<PasteFieldAttribute>()?.Any() == true)
            {
                var find = property.GetCustomAttributes<PasteFieldAttribute>().FirstOrDefault();
                if (find != null && find != default)
                {
                    target_property = find.Args1;
                }
            }

            // 检查实体是否有对应的属性
            var entityProperty = entityType.GetProperty(target_property);
            if (entityProperty != null)
            {
                //&& entityProperty.PropertyType == property.PropertyType 

                // 动态构建表达式: x => x.Property == value
                //query = ApplyEqualsFilter(query, entityType, entityProperty, value);
                return entityProperty;
            }
            else
            {
                //Console.WriteLine($"没有找到这个字段:{target_property} !");
            }
            return null;
        }

        /// <summary>
        /// 判断值是否为类型的默认值
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private bool IsDefaultValue(object value, Type type)
        {
            if (value == null)
                return true;

            // 值类型处理
            if (type.IsValueType)
            {
                // 可空类型
                if (Nullable.GetUnderlyingType(type) != null)
                {
                    if (value == null)
                        return true;

                    // 获取基础类型
                    type = Nullable.GetUnderlyingType(type);
                }

                // 创建默认值实例
                object defaultValue = Activator.CreateInstance(type);

                // 比较值
                return value.Equals(defaultValue);
            }

            // 引用类型处理
            if (type == typeof(string))
            {
                return string.IsNullOrEmpty(value.ToString());
            }

            return false;
        }

        /// <summary>
        /// 应用等于过滤条件的方法
        /// 简单应用过滤查询
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <param name="property"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private IQueryable ApplyEqualsFilter(IQueryable query, Type entityType, PropertyInfo property, object value)
        {
            var parameter = Expression.Parameter(entityType, "x");
            var propertyAccess = Expression.Property(parameter, property.Name);
            var constant = Expression.Constant(value);

            var equalExpression = Expression.Equal(propertyAccess, constant);
            var lambda = Expression.Lambda(equalExpression, parameter);


            var whereCallExpression = Expression.Call(
                typeof(Queryable),
                "Where",
                new Type[] { entityType },
                query.Expression,
                lambda);

            return query.Provider.CreateQuery(whereCallExpression);
        }

        /// <summary>
        /// 应用比较过滤条件（支持多种操作符）
        /// 请勿删除，是上面这个的扩展
        /// </summary>
        private IQueryable ApplyComparisonFilter(IQueryable query, Type entityType, PropertyInfo property, object value, string operatorName = "Equals")
        {
            var parameter = Expression.Parameter(entityType, "x");
            var propertyAccess = Expression.Property(parameter, property.Name);
            var constant = Expression.Constant(value, property.PropertyType);

            // 根据操作符名称构建表达式
            Expression comparisonExpression;
            switch (operatorName)
            {
                case "Equals":
                    comparisonExpression = Expression.Equal(propertyAccess, constant);
                    break;
                case "NotEquals":
                    comparisonExpression = Expression.NotEqual(propertyAccess, constant);
                    break;
                case "GreaterThan":
                    comparisonExpression = Expression.GreaterThan(propertyAccess, constant);
                    break;
                case "GreaterThanOrEqual":
                    comparisonExpression = Expression.GreaterThanOrEqual(propertyAccess, constant);
                    break;
                case "LessThan":
                    comparisonExpression = Expression.LessThan(propertyAccess, constant);
                    break;
                case "LessThanOrEqual":
                    comparisonExpression = Expression.LessThanOrEqual(propertyAccess, constant);
                    break;
                case "Contains":
                    // 处理字符串Contains
                    if (property.PropertyType == typeof(string))
                    {
                        var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });
                        comparisonExpression = Expression.Call(propertyAccess, containsMethod, constant);
                    }
                    else
                    {
                        // 处理集合Contains（如List<T>.Contains）
                        var containsMethod = property.PropertyType.GetMethod("Contains", new[] { property.PropertyType.GenericTypeArguments[0] });
                        comparisonExpression = Expression.Call(propertyAccess, containsMethod, constant);
                    }
                    break;
                default:
                    throw new ArgumentException($"不支持的操作符: {operatorName}");
            }

            var lambda = Expression.Lambda(comparisonExpression, parameter);
            var whereCallExpression = Expression.Call(
                typeof(Queryable),
                "Where",
                new Type[] { entityType },
                query.Expression,
                lambda);

            return query.Provider.CreateQuery(whereCallExpression);
        }

        ///// <summary>
        ///// 应用搜索关键词的方法
        ///// </summary>
        ///// <param name="query"></param>
        ///// <param name="entityType"></param>
        ///// <param name="keyword"></param>
        ///// <returns></returns>
        //private IQueryable ApplySearchKeyword(IQueryable query, Type entityType, string keyword)
        //{
        //    if (String.IsNullOrEmpty(keyword))
        //    {
        //        return query;
        //    }
        //    // 获取所有字符串类型的属性
        //    var stringProperties = entityType.GetProperties()
        //        .Where(p => p.PropertyType == typeof(string))
        //        .ToList();

        //    if (!stringProperties.Any())
        //        return query;

        //    // 构建 OR 表达式: x => x.Prop1.Contains(keyword) || x.Prop2.Contains(keyword) || ...
        //    var parameter = Expression.Parameter(entityType, "x");
        //    Expression orExpression = null;

        //    var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });

        //    foreach (var property in stringProperties)
        //    {
        //        var propertyAccess = Expression.Property(parameter, property.Name);
        //        var constant = Expression.Constant(keyword);
        //        var containsExpression = Expression.Call(propertyAccess, containsMethod, constant);

        //        if (orExpression == null)
        //            orExpression = containsExpression;
        //        else
        //            orExpression = Expression.OrElse(orExpression, containsExpression);
        //    }

        //    if (orExpression != null)
        //    {
        //        var lambda = Expression.Lambda(orExpression, parameter);

        //        var whereCallExpression = Expression.Call(
        //            typeof(Queryable),
        //            "Where",
        //            new Type[] { entityType },
        //            query.Expression,
        //            lambda);

        //        query = query.Provider.CreateQuery(whereCallExpression);
        //    }

        //    return query;
        //}

        /// <summary>
        /// 应用关键字搜索
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <param name="keyword"></param>
        /// <returns></returns>
        private IQueryable ApplySearchKeyword(IQueryable query, Type entityType, string keyword)
        {
            // 外部已确保keyword非空，这里仅做防御性校验
            if (string.IsNullOrEmpty(keyword))
            {
                return query;
            }

            var stringProperties = entityType.GetProperties()
                .Where(p => p.PropertyType == typeof(string) && p.GetCustomAttributes<PasteSearchAttribute>()?.Any() == true)
                .ToList();

            if (!stringProperties.Any())
            {
                return query;
            }

            var parameter = Expression.Parameter(entityType, "x");
            Expression orExpression = null;
            var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });

            foreach (var property in stringProperties)
            {
                // 只构建“属性包含关键词”的表达式，不添加任何与关键词为空相关的判断
                var propertyAccess = Expression.Property(parameter, property);
                var containsExpression = Expression.Call(
                    propertyAccess,
                    containsMethod,
                    Expression.Constant(keyword) // 直接使用关键词“bb”
                );

                orExpression = orExpression == null
                    ? containsExpression
                    : Expression.OrElse(orExpression, containsExpression);
            }

            var lambda = Expression.Lambda(orExpression, parameter);
            var whereCall = Expression.Call(
                typeof(Queryable),
                "Where",
                new[] { entityType },
                query.Expression,
                lambda
            );

            return query.Provider.CreateQuery(whereCall);
        }

        /// <summary>
        /// 计算 page  size  orderby
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        private IQueryable ApplyPagingAndSorting(IQueryable query, Type entityType, InputSearchBase input)
        {
            // 获取Id属性信息
            var idProperty = entityType.GetProperty("Id");
            if (idProperty == null)
            {
                throw new PasteCodeException($"实体 {entityType.Name} 不包含Id属性", 500);
            }

            // 构建排序表达式
            var parameter = Expression.Parameter(entityType, "x");
            var propertyAccess = Expression.Property(parameter, idProperty);
            var lambda = Expression.Lambda(propertyAccess, parameter);

            // 使用正确的属性类型作为排序键类型
            var orderByDescendingCall = Expression.Call(
                typeof(Queryable),
                "OrderByDescending",
                new Type[] { entityType, idProperty.PropertyType }, // 使用实际的属性类型
                query.Expression,
                lambda);

            query = query.Provider.CreateQuery(orderByDescendingCall);

            // 应用分页
            query = query.Skip((input.page - 1) * input.size).Take(input.size);

            return query;
        }


        /// <summary>
        /// 上面的补充，用于其他查询
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <param name="searchType"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        private IQueryable ApplyPagingAndSorting(IQueryable query, Type entityType, Type searchType, Object input)
        {
            // 获取Id属性信息
            var idProperty = entityType.GetProperty("Id");
            if (idProperty == null)
            {
                throw new PasteCodeException($"实体 {entityType.Name} 不包含Id属性", 500);
            }

            var page = 1;
            var size = 20;
            var orderby = String.Empty;

            foreach (var ii in searchType.GetProperties())
            {
                if (string.Equals(ii.Name, "page", StringComparison.CurrentCultureIgnoreCase))
                {
                    var _page = ii.GetValue(input);
                    int.TryParse(_page.ToString(), out page);
                    continue;
                }
                if (string.Equals(ii.Name, "size", StringComparison.CurrentCultureIgnoreCase))
                {
                    var _page = ii.GetValue(input);
                    int.TryParse(_page.ToString(), out size);
                    continue;
                }
                if (string.Equals(ii.Name, "orderby", StringComparison.CurrentCultureIgnoreCase))
                {
                    var _page = ii.GetValue(input);
                    orderby = _page.ToString().Trim();
                    continue;
                }
            }

            if (!String.IsNullOrEmpty(orderby))
            {
                query = query.OrderBy(orderby);
            }
            else
            {
                // 构建排序表达式 默认 OrderByDescending(x=>x.Id)
                var parameter = Expression.Parameter(entityType, "x");
                var propertyAccess = Expression.Property(parameter, idProperty);
                var lambda = Expression.Lambda(propertyAccess, parameter);

                // 使用正确的属性类型作为排序键类型
                var orderByDescendingCall = Expression.Call(
                    typeof(Queryable),
                    "OrderByDescending",
                    new Type[] { entityType, idProperty.PropertyType }, // 使用实际的属性类型
                    query.Expression,
                    lambda);

                query = query.Provider.CreateQuery(orderByDescendingCall);
            }
            // 应用分页
            query = query.Skip((page - 1) * size).Take(size);

            return query;
        }

        /// <summary>
        /// 执行计数查询的方法
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <returns></returns>
        private async Task<int> ExecuteCountQuery(IQueryable query, Type entityType)
        {
            var countMethod = typeof(Queryable)
                .GetMethods()
                .First(m => m.Name == "Count" && m.GetParameters().Length == 1)
                .MakeGenericMethod(entityType);

            return (int)await Task.FromResult(countMethod.Invoke(null, new object[] { query }));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="query"></param>
        /// <param name="entityType"></param>
        /// <returns></returns>
        /// <exception cref="PasteCodeException"></exception>
        private async Task<List<object>> ExecuteQuery(IQueryable query, Type entityType)
        {
            try
            {
                // 获取 EntityFrameworkQueryableExtensions 类型
                var extensionsType = typeof(EntityFrameworkQueryableExtensions);

                // 查找 ToListAsync 方法，匹配名称、泛型和参数
                var toListMethod = extensionsType.GetMethods(BindingFlags.Static | BindingFlags.Public)
                    .First(m =>
                        m.Name == "ToListAsync" &&
                        m.IsGenericMethodDefinition &&
                        m.GetParameters().Length == 2 &&  // 注意：有两个参数（查询和 CancellationToken）
                        m.GetParameters()[0].ParameterType == typeof(IQueryable<>).MakeGenericType(m.GetGenericArguments()[0]) &&
                        m.GetParameters()[1].ParameterType == typeof(CancellationToken));

                // 构建泛型方法
                var genericToListMethod = toListMethod.MakeGenericMethod(entityType);

                // 调用方法，传入 CancellationToken.None
                var task = (Task)genericToListMethod.Invoke(null, new object[] { query, CancellationToken.None });
                await task;

                // 获取结果
                var resultProperty = task.GetType().GetProperty("Result");
                var entities = (IEnumerable)resultProperty.GetValue(task);

                return entities.Cast<object>().ToList();
            }
            catch (Exception ex)
            {
                throw new PasteCodeException($"执行查询时发生错误: {ex.Message}", 500);
            }
        }

        /// <summary>
        /// 映射实体到DTO的方法
        /// </summary>
        /// <param name="entities"></param>
        /// <param name="entityType"></param>
        /// <param name="dtoType"></param>
        /// <returns></returns>
        private List<object> MapEntitiesToDtos(List<object> entities, Type entityType, Type dtoType)
        {
            var result = new List<object>();

            foreach (var entity in entities)
            {
                var dto = Activator.CreateInstance(dtoType);

                // 获取DTO类型的所有可写属性
                var dtoProperties = dtoType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                    .Where(p => p.CanWrite);

                foreach (var dtoProperty in dtoProperties)
                {
                    // 查找实体中对应的属性
                    var entityProperty = entityType.GetProperty(dtoProperty.Name);

                    // 如果属性名称和类型都匹配，则复制值
                    if (entityProperty != null && entityProperty.PropertyType == dtoProperty.PropertyType)
                    {
                        var value = entityProperty.GetValue(entity);
                        dtoProperty.SetValue(dto, value);
                    }
                }
                result.Add(dto);
            }
            return result;
        }
        // 类型缓存
        //private readonly ConcurrentDictionary<string, Type> _typeCache = new ConcurrentDictionary<string, Type>();
        #endregion

        #region 

        /// <summary>
        /// 动态构建Select表达式，将实体投影到DTO
        /// </summary>
        private Expression<Func<object, object>> BuildSelectExpressionV1(Type entityType, Type dtoType)
        {
            var parameter = Expression.Parameter(typeof(object), "x");
            var convertedParameter = Expression.Convert(parameter, entityType);

            // 创建DTO构造表达式
            var dtoNewExpression = Expression.New(dtoType);

            // 构建属性赋值绑定
            var bindings = new List<MemberBinding>();
            foreach (var dtoProperty in dtoType.GetProperties())
            {
                // 查找实体中对应的属性
                var entityProperty = entityType.GetProperty(dtoProperty.Name);

                // 如果属性名称和类型都匹配，则添加到绑定
                if (entityProperty != null && entityProperty.PropertyType == dtoProperty.PropertyType)
                {
                    var propertyAccess = Expression.Property(convertedParameter, entityProperty);
                    bindings.Add(Expression.Bind(dtoProperty, propertyAccess));
                }
            }

            // 创建初始化器表达式
            var initExpression = Expression.MemberInit(dtoNewExpression, bindings);

            // 转换为object类型
            var convertExpression = Expression.Convert(initExpression, typeof(object));

            // 创建lambda表达式
            return Expression.Lambda<Func<object, object>>(convertExpression, parameter);
        }

        //private LambdaExpression BuildSelectExpression(Type entityType, Type dtoType)
        //{
        //    // 创建参数表达式 (x => ...)
        //    var parameter = Expression.Parameter(entityType, "x");

        //    // 创建DTO属性的绑定
        //    var bindings = dtoType.GetProperties()
        //        .Where(p => p.CanWrite)
        //        .Select(p =>
        //        {
        //            // 查找实体类型中是否有同名属性
        //            var entityProperty = entityType.GetProperty(p.Name);
        //            if (entityProperty != null && entityProperty.CanRead)
        //            {
        //                // 创建属性访问表达式 x.Property
        //                var propertyAccess = Expression.Property(parameter, entityProperty);

        //                // 如果需要类型转换，添加Convert操作
        //                if (p.PropertyType != entityProperty.PropertyType)
        //                {
        //                    propertyAccess = Expression.Convert(propertyAccess, p.PropertyType);
        //                }

        //                return Expression.Bind(p, propertyAccess);
        //            }

        //            return null;
        //        })
        //        .Where(b => b != null)
        //        .ToList();

        //    // 创建DTO对象初始化表达式
        //    var dtoInit = Expression.MemberInit(
        //        Expression.New(dtoType),
        //        bindings);

        //    // 创建lambda表达式 x => new Dto { ... }
        //    return Expression.Lambda(dtoInit, parameter);
        //}

        /// <summary>
        /// 直接查询并投影为DTO
        /// </summary>
        private async Task<List<object>> ExecuteProjectionQuery(IQueryable query, Type entityType, Type dtoType)
        {
            try
            {

                // 构建Select表达式
                var selectExpression = BuildSelectExpression(entityType, dtoType);

                // 创建泛型Func类型 (EntityType -> DtoType)
                var funcType = typeof(Func<,>).MakeGenericType(entityType, dtoType);

                // 创建lambda表达式
                var lambda = Expression.Lambda(funcType, selectExpression.Body, selectExpression.Parameters[0]);

                // 构建Select方法
                var selectMethod = typeof(Queryable).GetMethods()
                    .First(m => m.Name == "Select" && m.GetParameters().Length == 2)
                    .MakeGenericMethod(entityType, dtoType);

                // 应用Select投影
                var projectedQuery = selectMethod.Invoke(null, new object[] { query, lambda });

                var toListMethod = typeof(EntityFrameworkQueryableExtensions).GetMethods()
                    .First(m => m.Name == "ToListAsync" && m.GetParameters().Length == 2)
                    .MakeGenericMethod(typeof(object));
                //Console.WriteLine("line 1640");
                var task = (Task)toListMethod.Invoke(null, new object[] { projectedQuery, CancellationToken.None });
                await task;
                //Console.WriteLine("line 1643");
                var resultProperty = task.GetType().GetProperty("Result");
                return (List<object>)resultProperty.GetValue(task);

            }
            catch (Exception ex)
            {
                throw new PasteCodeException($"执行投影查询时发生错误: {ex.Message}", 500);
            }
        }

        private LambdaExpression BuildSelectExpression(Type entityType, Type dtoType)
        {
            // 创建参数表达式 (x => ...)
            var parameter = Expression.Parameter(entityType, "x");

            // 创建DTO属性的绑定
            var bindings = dtoType.GetProperties()
                .Where(p => p.CanWrite)
                .Select(p =>
                {
                    // 查找实体类型中是否有同名属性
                    var entityProperty = entityType.GetProperty(p.Name);
                    if (entityProperty != null && entityProperty.CanRead)
                    {
                        // 创建属性访问表达式 x.Property
                        var propertyAccess = Expression.Property(parameter, entityProperty);

                        // 如果需要类型转换，添加Convert操作
                        //if (p.PropertyType != entityProperty.PropertyType)
                        //{
                        //    propertyAccess = Expression.Convert(propertyAccess, p.PropertyType);
                        //}

                        return Expression.Bind(p, propertyAccess);
                    }

                    return null;
                })
                .Where(b => b != null)
                .ToList();

            // 创建DTO对象初始化表达式
            var dtoInit = Expression.MemberInit(
                Expression.New(dtoType),
                bindings);

            // 创建lambda表达式 x => new Dto { ... }
            return Expression.Lambda(dtoInit, parameter);
        }

        /// <summary>
        /// 构建ID查询条件
        /// </summary>
        private IQueryable BuildIdQuery(Type entityType, HashSet<object> ids)
        {
            // 获取DbSet
            var dbSetMethod = _dbContext.GetType()
                .GetMethods()
                .First(m => m.Name == "Set" && m.IsGenericMethod);
            var genericDbSetMethod = dbSetMethod.MakeGenericMethod(entityType);
            var dbSet = genericDbSetMethod.Invoke(_dbContext, null);
            var queryable = (IQueryable)dbSet;

            //if (ids.Count == 0)
            //{
            //    return queryable.Where(x => false); // 返回空结果
            //}

            // 动态构建ID查询表达式: x => ids.Contains(x.Id)
            var parameter = Expression.Parameter(entityType, "x");
            var idProperty = entityType.GetProperty("Id");
            var propertyAccess = Expression.Property(parameter, idProperty);

            // 创建包含所有ID的常量表达式
            var method = typeof(Enumerable).GetMethods()
                .First(m => m.Name == "Contains" && m.GetParameters().Length == 2)
                .MakeGenericMethod(idProperty.PropertyType);

            var constant = Expression.Constant(ids);
            var containsExpression = Expression.Call(method, constant, propertyAccess);

            var lambda = Expression.Lambda(containsExpression, parameter);
            var whereCallExpression = Expression.Call(
                typeof(Queryable),
                "Where",
                new Type[] { entityType },
                queryable.Expression,
                lambda);

            return queryable.Provider.CreateQuery(whereCallExpression);
        }


        #endregion

        /// <summary>
        /// 
        /// </summary>
        /// <param name="entityType"></param>
        /// <returns></returns>
        private object GetDbSet(Type entityType)
        {
            var dbSetMethod = _dbContext.GetType()
                .GetMethods()
                .First(m => m.Name == "Set" && m.IsGenericMethod);

            return dbSetMethod.MakeGenericMethod(entityType).Invoke(_dbContext, null);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        private object GetPropertyValue(object obj, string propertyName)
        {
            var property = obj.GetType().GetProperty(propertyName);
            return property?.GetValue(obj);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="propertyName"></param>
        /// <param name="value"></param>
        private void SetPropertyValue(object obj, string propertyName, object value)
        {
            var property = obj.GetType().GetProperty(propertyName);
            if (property != null && property.CanWrite)
            {
                // 处理类型转换
                if (value != null && property.PropertyType != value.GetType())
                {
                    value = Convert.ChangeType(value, property.PropertyType);
                }

                property.SetValue(obj, value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <param name="destination"></param>
        /// <param name="sourceType"></param>
        /// <param name="destinationType"></param>
        private void MapProperties(object source, object destination, Type sourceType, Type destinationType)
        {
            // 获取源类型的所有可读属性
            var sourceProperties = sourceType.GetProperties()
                .Where(p => p.CanRead)
                .ToList();

            // 获取目标类型的所有可写属性
            var destinationProperties = destinationType.GetProperties()
                .Where(p => p.CanWrite)
                .ToList();

            // 映射相同名称和类型的属性
            foreach (var sourceProperty in sourceProperties)
            {
                var destinationProperty = destinationProperties
                    .FirstOrDefault(p => p.Name == sourceProperty.Name && p.PropertyType == sourceProperty.PropertyType);

                if (destinationProperty != null)
                {
                    var value = sourceProperty.GetValue(source);
                    destinationProperty.SetValue(destination, value);
                }
            }
        }


        #endregion

    }

}

